#ifndef CONJTEST_H
#define CONJTEST_H

#include "ConjString.h"
#include <iostream>
#include <string>

/**
 * Esta clase realiza los test de unidad solamente del conjunto.
 * Se asume que las clases utilizadas funcionan correctame.
*/
class ConjStringTest
{
	public:
	ConjStringTest();
        void StartTest ();
        void Result ();

	protected:
    	
		/** 
		 * Aca testeamos que dado un conjunto recien creado, no tenga elementos, y al 
		 * evaluar sobre elementos en el rango y fuera pertenece sea siempre falso.
		*/
	    bool conjStringVacio();
	    bool conjStringCopia();
		bool agregar();
		bool eliminar();
	    bool pertenece();
		bool dameTamanio();
		bool igualPorCopia();
		bool vacio();
	private:
		//string test;
		ConjString *conj;
		ConjString *conj2;
		string temp;
		int ok;
		int error;
};
ConjStringTest::ConjStringTest(){
	//test = new ostream(); 
//	res = new ostream(cout);
}
void ConjStringTest::StartTest(){
	ok=0;
	error=0;

	if(this->conjStringVacio()){
        ok++;
	}else error++;
    system("PAUSE");
	if(this->agregar()){
        ok++;
	}else error++;
    system("PAUSE");
	if(this->eliminar()){
        ok++;
	}else error++;
    system("PAUSE");
	if(this->pertenece()){
        ok++;
	}else error++;
    system("PAUSE");
	if(this->dameTamanio()){
        ok++;
	}else error++;
    system("PAUSE");

	if(this->igualPorCopia()){
        ok++;
	}else error++;
    system("PAUSE");
	if(this->conjStringCopia()){
        ok++;
	}else error++;
    system("PAUSE");


	if(this->vacio()){
        ok++;
	}else error++;
    system("PAUSE");
}
void ConjStringTest::Result (){
 	cout << "CONJ test Ok:" << ok << endl;
	cout << "CONJ test error:" << error << endl;
};

/**
** esto verifica que los conjunto creados esten vacios
**/
bool ConjStringTest::conjStringVacio(){
	cout << "CONJ::conjStringVacio:" << endl;
	
	cout << "CONJ::creo conj conj2:" << endl;
	conj = new ConjString ();
	cout << "CONJ :" << endl;
	ConjString conj2;
	cout << "CONJ2:" << endl;
	if(!conj->vacio()){
		cout << "CONJ::CONJ tiene basura:" << endl;
		return false;
		cout << "CONJ::ConjStringCrear:ERR" << endl;
	}
	if(!conj2.vacio()){
		cout << "CONJ::CONJ2 tiene basura:" << endl;
		cout << "CONJ::ConjStringCrear:ERR" << endl;
		return false;
	}
	cout << "CONJ::conjStringVacio:OK" << endl;
	return true;
}
/**
** verifica que la creacion de un conjunto por copia funcione correctamente
**/
bool ConjStringTest::conjStringCopia(){
   	cout << "CONJ::conjStringCopia" << endl;
    ConjString *Conj2;
	//Le agregamos algo que podamos identificar dentro del conjunto a ser copiado
	// Crea un ConjString como copia de otro. 
    Conj2 = new ConjString(*conj);

    conj->agregar("hayalliasing");
    if(Conj2->pertenece("hayalliasing")){
    	cout << "CONJ::conjStringCopia:OK" << endl;
        return false;
    }
	cout << "CONJ::conjStringCopia:OK" << endl;
	return true;
}


bool ConjStringTest::agregar(){
	cout << endl << "CONJ::AGREGAR:" << endl;
	cout << "CONJ::definendo algunos elementos:" << endl;
	//defino algunos elementoa
	conj->agregar("holasie");
	cout << "holasie" << endl;
	conj->agregar("h");
	cout << "h" << endl;
	conj->agregar("holgado");
	cout << "holgado" << endl << endl;
	cout << "veo el conj:" << endl << *conj << endl << endl;
	if(!conj->pertenece("holasie")){
       	cout << "CONJ::agregar:ERR" << endl;
		return false;
	}else if(!conj->pertenece("h")){
       	cout << "CONJ::agregar:ERR" << endl;
		return false;
	}else if(!conj->pertenece("holgado")){
       	cout << "CONJ::agregar:ERR" << endl;
		return false;
	}
//reagrego
   	conj->agregar("holgado");
	if(!conj->pertenece("holgado")){
       	cout << "CONJ::agregar:ERR" << endl;
		return false;
	}
   	cout << "CONJ::agregar:OK" << endl;	
	return true;
}

bool ConjStringTest::eliminar(){
    ConjString Conj2;
	cout << "CONJ::ELIMINAR:" << endl ;
	int tam = Conj2.dameTamano(); 
	Conj2.eliminar("holgados");
	Conj2.eliminar("holga");
	if(tam != Conj2.dameTamano()){
       	cout << "CONJ::eliminar:ERR" << endl;
		return false;
	}
	cout << endl << "borrar elementos que no esten: (holgados, holga)" << endl;
	cout << "veo como queda el conjunto:" << endl << Conj2 << endl << endl;
	
	Conj2.eliminar("holgado");
	if(tam == Conj2.dameTamano()){
       	cout << "CONJ::eliminar:ERR" << endl;
		return false;
    }
	if(Conj2.pertenece("holgado")){
       	cout << "CONJ::eliminar:ERR" << endl;
		return false;
	}
	cout << endl << "elimino alguna elementos que esten: (holgado)" << endl;
	cout << "veo como queda el conjunto:" << endl << Conj2 << endl << endl;
   	cout << "CONJ::eliminar:OK" << endl;
	return true;

}

bool ConjStringTest::pertenece(){
;
	//pertenece
    cout << "CONJ::PERTENECE:" << endl;
    ConjString conj2;
    if(conj2.pertenece("holasie")){
		cout << "no funciono, devuelve siempre true" << endl;
		return false;
    }
    conj2.agregar("holasie");
	if(!conj2.pertenece("holasie")){
		cout << "no detecta los elementos del conjunto" << endl;
		return false;
    }
	//res2 = dicc.obtener("noEncontrado"); // esto deberia fallar
	cout << endl << endl;
   	cout << "CONJ::PERTENECE:OK" << endl;
	return true;
}

bool ConjStringTest::dameTamanio(){
	//pertenece
    cout << "CONJ::DAMETAMANO:" << endl;
    ConjString conj2;
    if(conj2.dameTamano()!=0){
		cout << "no funciono, devuelve "<< conj2.dameTamano() <<" cuando deberia ser 0" << endl;
		return false;
    }
    conj2.agregar("holasie");
	if(conj2.dameTamano()!=1){
		cout << "no funciono, devuelve "<< conj2.dameTamano() <<" cuando deberia ser 1" << endl;
		return false;
    }
    conj2.eliminar("holasie");
	if(conj2.dameTamano()!=0){
		cout << "no funciono, devuelve "<< conj2.dameTamano() <<" cuando deberia ser 0" << endl;
		return false;
    }
	//res2 = dicc.obtener("noEncontrado"); // esto deberia fallar
   	cout << "CONJ::DAMETAMANO:OK" << endl;
	return true;
}
bool ConjStringTest::igualPorCopia(){
    conj2 = new ConjString();
	cout << "CONJ::OPERADOR=:: conj = conj2:" << endl;
		*conj2=*conj;
		//veo si apuntan al mismo lugar los punteros
		if(&conj2==&conj){
           	cout << "CONJ::igualPorCopia:ERR1" << endl;
			return false;
		}
		conj->agregar("alliasing");
		if(conj2->pertenece("alliasing")){
           	cout << "CONJ::igualPorCopia:ERR2" << endl;
			return false;
		}
	//redefino

	cout << "CONJ: copio sobre si mismo dicc" << endl << endl;
	    //para estar seguro que hay algo en el conjunto
	    conj->agregar("copia");
	    int v=conj->dameTamano();

		*conj = *conj;
        if(conj->vacio()){
           	cout << "CONJ::igualPorCopia:ERR3" << endl;
   			return false;
		}
        if(v != conj->dameTamano()){
          	cout << "CONJ::igualPorCopia:ERR4" << endl;
   			return false;
        }
      	cout << "CONJ::igualPorCopia:OK" << endl;
	    return true;
}

bool ConjStringTest::vacio(){
	temp += "CONJ::VACIO:\n" ;
		//bool vacio() const;
	return false;
}


#endif


